//基础数据类型
(() => {
    //布尔值
    //基本语法
    //let 变量名:数据类型 = 值
    let flag: boolean = false
    console.log(flag);

    //数字类型
    let a1: number = 10 //十进制
    let a2: number = 0b1010 //二进制
    let a3: number = 0o12 //八进制
    let a4: number = 0xa //十六进制
    console.log(a1)
    console.log(a2)
    console.log(a3)
    console.log(a4)

    //字符串类型
    let str1: string = '床前明月光'
    let str2: string = '疑是地上霜'
    let str3: string = '举头望明月'
    let str4: string = '低头思故乡'
    console.log(`${str1},${str2},${str3},${str4}`)

    //字符串和数字拼接
    let str5: string = '我有很多的钱'
    let a5: number = 10000
    console.log(str5 + a5);

    //总结：ts中变量一开始是什么类型，那么后期赋值的时候，只能用这个类型的数据，是不允许用其它类型的数据赋值给当前的这个变量中

    console.log("====================");
    let und: undefined = undefined
    let nll: null = null
    console.log(und);
    console.log(nll);
    //undefined和null都可以作为其他类型的子类型，把undefined和null赋值给其它类型的变量，如：number类型的变量
    // let num2:number = undefined
    let num2: number = null
    console.log(num2);
    console.log("====================");

    //数组类型
    //数组定义方式1
    //语法：let 变量名:数据类型[] = [值1,值2,值3]
    let arr1: number[] = [10, 20, 30, 40, 50]
    console.log(arr1);

    //数组定义方法2:泛型的写法
    //语法：let 变量名：Arrary<数据类型> = [值1,值2,,值3]
    let arr2: Array<number> = [100, 200, 300]
    console.log(arr2);
    //注意问题：数组定义后，里面的数据的类型必须和定义数组的时候类型是一致的，否则有错误提示信息，也不会编译通过！

    //元组类型:在定义数组的时候，类型和数据的个数一开始就已经限定了
    let arr3: [string, number, boolean] = ['100', 200, false]
    console.log(arr3);
    //注意问题：元祖类型在使用的时候，数据类型的位置和数据的个数应该和在定义元祖的时候的数据类型及位置应该是一致的

    console.log("====================");
    // 枚举值
    enum Color {
        red,
        green,
        blue
    }
    // 定义一个Color的枚举类型的变量来接收枚举值
    let color: Color = Color.red
    console.log(color);
    console.log(Color.red, Color.green, Color.blue);
    console.log(Color[2]);
    enum Person {
        男,
        女
    }
    console.log(Person[0]);
    console.log("====================");
    // any类型
    let data: any = 100
    data = '哈哈哈'
    console.log(data);
    let arr: any[] = [100, '呵呵呵呵', false]
    //any有优点也有缺点
    // console.log(arr[0].split(''));
    console.log(arr[1].split(''));
    console.log("====================");
    // void 类型，在函数声明的时候，小括号后面使用:void，代表的是该函数没有任何的返回值
    function showMsg(): void {
        console.log('展示信息');
    }
    console.log(showMsg());
    //可以定义一个void类型的变量用来接收undefined，意义不大
    let vd: void = undefined
    console.log(vd);
    console.log("====================");
    // Object类型
    function obj(params: object): object {
        console.log(params);
        return {
            name: "张三",
            age: 20
        }
    }
    // console.log(obj('123'));//报错
    console.log(obj(new String('123')));
    console.log(obj({
        name: "李四",
        age: 30
    }));
    console.log("====================");
    // 联合类型（Union Type）表示取值可以为多种类型中的一种
    function getObj(params: string | number): string {
        console.log(params);
        return params.toString()
    }
    console.log(getObj(2222));
    // 类型断言
    // 定义一个函数得到一个数字或者字符串长度
    function getString(str: string | number): number {
        if ((<string>str).length) {
            // return (<string>str).length
            return (str as string).length
        } else {
            return str.toString().length
        }
    }
    console.log(getString("456"));

    //类型推断:没有明确的指定类型的时候推断出一个类型
    let txt = 100//number类型
    // txt = "111"
    console.log(txt);
    let str
    str = 777
    str = "22222"
    console.log(str);
    
    


})()